home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / gnu / make-367.lha / make-3.67 / misc.c < prev    next >
C/C++ Source or Header  |  1993-04-15  |  15KB  |  688 lines
  1. /* Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
  2. This file is part of GNU Make.
  3.  
  4. GNU Make is free software; you can redistribute it and/or modify
  5. it under the terms of the GNU General Public License as published by
  6. the Free Software Foundation; either version 2, or (at your option)
  7. any later version.
  8.  
  9. GNU Make is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. GNU General Public License for more details.
  13.  
  14. You should have received a copy of the GNU General Public License
  15. along with GNU Make; see the file COPYING.  If not, write to
  16. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  17.  
  18. #include "make.h"
  19. #include "dep.h"
  20.  
  21.  
  22. /* Compare strings *S1 and *S2.
  23.    Return negative if the first is less, positive if it is greater,
  24.    zero if they are equal.  */
  25.  
  26. int
  27. alpha_compare (s1, s2)
  28.      char **s1, **s2;
  29. {
  30.   if (**s1 != **s2)
  31.     return **s1 - **s2;
  32.   return strcmp (*s1, *s2);
  33. }
  34.  
  35. /* Discard each backslash-newline combination from LINE.
  36.    Backslash-backslash-newline combinations become backslash-newlines.
  37.    This is done by copying the text at LINE into itself.  */
  38.  
  39. void
  40. collapse_continuations (line)
  41.      char *line;
  42. {
  43.   register char *in, *out, *p;
  44.   register int backslash;
  45.   register unsigned int bs_write;
  46.  
  47.   in = index (line, '\n');
  48.   if (in == 0)
  49.     return;
  50.  
  51.   out = in;
  52.   if (out > line)
  53.     while (out[-1] == '\\')
  54.       --out;
  55.  
  56.   while (*in != '\0')
  57.     {
  58.       /* BS_WRITE gets the number of quoted backslashes at
  59.      the end just before IN, and BACKSLASH gets nonzero
  60.      if the next character is quoted.  */
  61.       backslash = 0;
  62.       bs_write = 0;
  63.       for (p = in - 1; p >= line && *p == '\\'; --p)
  64.     {
  65.       if (backslash)
  66.         ++bs_write;
  67.       backslash = !backslash;
  68.  
  69.       /* It should be impossible to go back this far without exiting,
  70.          but if we do, we can't get the right answer.  */
  71.       if (in == out - 1)
  72.         abort ();
  73.     }
  74.  
  75.       /* Output the appropriate number of backslashes.  */
  76.       while (bs_write-- > 0)
  77.     *out++ = '\\';
  78.  
  79.       /* Skip the newline.  */
  80.       ++in;
  81.  
  82.       /* If the newline is quoted, discard following whitespace
  83.      and any preceding whitespace; leave just one space.  */
  84.       if (backslash)
  85.     {
  86.       in = next_token (in);
  87.       while (out > line && isblank (out[-1]))
  88.         --out;
  89.       *out++ = ' ';
  90.     }
  91.       else
  92.     /* If the newline isn't quoted, put it in the output.  */
  93.     *out++ = '\n';
  94.  
  95.       /* Now copy the following line to the output.
  96.      Stop when we find backslashes followed by a newline.  */
  97.       while (*in != '\0')
  98.     if (*in == '\\')
  99.       {
  100.         p = in + 1;
  101.         while (*p == '\\')
  102.           ++p;
  103.         if (*p == '\n')
  104.           {
  105.         in = p;
  106.         break;
  107.           }
  108.         while (in < p)
  109.           *out++ = *in++;
  110.       }
  111.     else
  112.       *out++ = *in++;
  113.     }
  114.  
  115.   *out = '\0';
  116. }
  117.  
  118.  
  119. /* Remove comments from LINE.
  120.    This is done by copying the text at LINE onto itself.  */
  121.  
  122. void
  123. remove_comments (line)
  124.      char *line;
  125. {
  126.   register char *p, *p2;
  127.   register int backslash;
  128.   register unsigned int bs_write;
  129.  
  130.   while (1)
  131.     {
  132.       p = index (line, '#');
  133.       if (p == 0)
  134.     break;
  135.  
  136.       backslash = 0;
  137.       bs_write = 0;
  138.       for (p2 = p - 1; p2 >= line && *p2 == '\\'; --p2)
  139.     {
  140.       if (backslash)
  141.         ++bs_write;
  142.       backslash = !backslash;
  143.     }
  144.  
  145.       if (!backslash)
  146.     {
  147.       /* Cut off the line at the #.  */
  148.       *p = '\0';
  149.       break;
  150.     }
  151.  
  152.       /* strcpy better copy left to right.  */
  153.       line = p;
  154.       strcpy (p2 + 1 + bs_write, line);
  155.     }
  156. }
  157.  
  158. /* Print N spaces (used by DEBUGPR for target-depth).  */
  159.  
  160. void
  161. print_spaces (n)
  162.      register unsigned int n;
  163. {
  164.   while (n-- > 0)
  165.     putchar (' ');
  166. }
  167.  
  168.  
  169. /* Return a newly-allocated string whose contents
  170.    concatenate those of s1, s2, s3.  */
  171.  
  172. char *
  173. concat (s1, s2, s3)
  174.      register char *s1, *s2, *s3;
  175. {
  176.   register unsigned int len1, len2, len3;
  177.   register char *result;
  178.  
  179.   len1 = *s1 != '\0' ? strlen (s1) : 0;
  180.   len2 = *s2 != '\0' ? strlen (s2) : 0;
  181.   len3 = *s3 != '\0' ? strlen (s3) : 0;
  182.  
  183.   result = (char *) xmalloc (len1 + len2 + len3 + 1);
  184.  
  185.   if (*s1 != '\0')
  186.     bcopy (s1, result, len1);
  187.   if (*s2 != '\0')
  188.     bcopy (s2, result + len1, len2);
  189.   if (*s3 != '\0')
  190.     bcopy (s3, result + len1 + len2, len3);
  191.   *(result + len1 + len2 + len3) = '\0';
  192.  
  193.   return result;
  194. }
  195.  
  196. /* Print a message on stdout.  */
  197.  
  198. void
  199. message (s1, s2, s3, s4, s5, s6)
  200.      char *s1, *s2, *s3, *s4, *s5, *s6;
  201. {
  202.   if (makelevel == 0)
  203.     printf ("%s: ", program);
  204.   else
  205.     printf ("%s[%u]: ", program, makelevel);
  206.   printf (s1, s2, s3, s4, s5, s6);
  207.   putchar ('\n');
  208.   fflush (stdout);
  209. }
  210.  
  211. /* Print an error message and exit.  */
  212.  
  213. /* VARARGS1 */
  214. void
  215. fatal (s1, s2, s3, s4, s5, s6)
  216.      char *s1, *s2, *s3, *s4, *s5, *s6;
  217. {
  218.   if (makelevel == 0)
  219.     fprintf (stderr, "%s: *** ", program);
  220.   else
  221.     fprintf (stderr, "%s[%u]: *** ", program, makelevel);
  222.   fprintf (stderr, s1, s2, s3, s4, s5, s6);
  223.   fputs (".  Stop.\n", stderr);
  224.  
  225.   die (1);
  226. }
  227.  
  228. /* Print error message.  `s1' is printf control string, `s2' is arg for it. */
  229.  
  230. /* VARARGS1 */
  231.  
  232. void
  233. error (s1, s2, s3, s4, s5, s6)
  234.      char *s1, *s2, *s3, *s4, *s5, *s6;
  235. {
  236.   if (makelevel == 0)
  237.     fprintf (stderr, "%s: ", program);
  238.   else
  239.     fprintf (stderr, "%s[%u]: ", program, makelevel);
  240.   fprintf (stderr, s1, s2, s3, s4, s5, s6);
  241.   putc ('\n', stderr);
  242.   fflush (stderr);
  243. }
  244.  
  245. void
  246. makefile_error (file, lineno, s1, s2, s3, s4, s5, s6)
  247.      char *file;
  248.      unsigned int lineno;
  249.      char *s1, *s2, *s3, *s4, *s5, *s6;
  250. {
  251.   fprintf (stderr, "%s:%u: ", file, lineno);
  252.   fprintf (stderr, s1, s2, s3, s4, s5, s6);
  253.   putc ('\n', stderr);
  254.   fflush (stderr);
  255. }
  256.  
  257. void
  258. makefile_fatal (file, lineno, s1, s2, s3, s4, s5, s6)
  259.      char *file;
  260.      unsigned int lineno;
  261.      char *s1, *s2, *s3, *s4, *s5, *s6;
  262. {
  263.   fprintf (stderr, "%s:%u: *** ", file, lineno);
  264.   fprintf (stderr, s1, s2, s3, s4, s5, s6);
  265.   fputs (".  Stop.\n", stderr);
  266.  
  267.   die (1);
  268. }
  269.  
  270. /* Print an error message from errno.  */
  271.  
  272. void
  273. perror_with_name (str, name)
  274.      char *str, *name;
  275. {
  276.   extern int errno, sys_nerr;
  277.   extern char *sys_errlist[];
  278.  
  279.   if (errno < sys_nerr)
  280.     error ("%s%s: %s", str, name, sys_errlist[errno]);
  281.   else
  282.     error ("%s%s: Unknown error %d", str, name, errno);
  283. }
  284.  
  285. /* Print an error message from errno and exit.  */
  286.  
  287. void
  288. pfatal_with_name (name)
  289.      char *name;
  290. {
  291.   extern int errno, sys_nerr;
  292.   extern char *sys_errlist[];
  293.  
  294.   if (errno < sys_nerr)
  295.     fatal ("%s: %s", name, sys_errlist[errno]);
  296.   else
  297.     fatal ("%s: Unknown error %d", name, errno);
  298.  
  299.   /* NOTREACHED */
  300. }
  301.  
  302. /* Like malloc but get fatal error if memory is exhausted.  */
  303.  
  304. #undef xmalloc
  305. #undef xrealloc
  306.  
  307. char *
  308. xmalloc (size)
  309.      unsigned int size;
  310. {
  311.   char *result = (char *) malloc (size);
  312.   if (result == 0)
  313.     fatal ("virtual memory exhausted");
  314.   return result;
  315. }
  316.  
  317.  
  318. char *
  319. xrealloc (ptr, size)
  320.      char *ptr;
  321.      unsigned int size;
  322. {
  323.   char *result = (char *) realloc (ptr, size);
  324.   if (result == 0)
  325.     fatal ("virtual memory exhausted");
  326.   return result;
  327. }
  328.  
  329. char *
  330. savestring (str, length)
  331.      char *str;
  332.      unsigned int length;
  333. {
  334.   register char *out = (char *) xmalloc (length + 1);
  335.   if (length > 0)
  336.     bcopy (str, out, length);
  337.   out[length] = '\0';
  338.   return out;
  339. }
  340.  
  341. /* Search string BIG (length BLEN) for an occurrence of
  342.    string SMALL (length SLEN).  Return a pointer to the
  343.    beginning of the first occurrence, or return nil if none found.  */
  344.  
  345. char *
  346. sindex (big, blen, small, slen)
  347.      char *big;
  348.      unsigned int blen;
  349.      char *small;
  350.      unsigned int slen;
  351. {
  352.   register unsigned int b;
  353.  
  354.   if (blen < 1)
  355.     blen = strlen (big);
  356.   if (slen < 1)
  357.     slen = strlen (small);
  358.  
  359.   for (b = 0; b < blen; ++b)
  360.     if (big[b] == *small && !strncmp (&big[b + 1], small + 1, slen - 1))
  361.       return (&big[b]);
  362.  
  363.   return 0;
  364. }
  365.  
  366. /* Limited INDEX:
  367.    Search through the string STRING, which ends at LIMIT, for the character C.
  368.    Returns a pointer to the first occurrence, or nil if none is found.
  369.    Like INDEX except that the string searched ends where specified
  370.    instead of at the first null.  */
  371.  
  372. char *
  373. lindex (s, limit, c)
  374.      register char *s, *limit;
  375.      int c;
  376. {
  377.   while (s < limit)
  378.     if (*s++ == c)
  379.       return s - 1;
  380.  
  381.   return 0;
  382. }
  383.  
  384. /* Return the address of the first whitespace or null in the string S.  */
  385.  
  386. char *
  387. end_of_token (s)
  388.      char *s;
  389. {
  390.   register char *p = s;
  391.   register int backslash = 0;
  392.  
  393.   while (*p != '\0' && (backslash || !isblank (*p)))
  394.     {
  395.       if (*p++ == '\\')
  396.     {
  397.       backslash = !backslash;
  398.       while (*p == '\\')
  399.         {
  400.           backslash = !backslash;
  401.           ++p;
  402.         }
  403.     }
  404.       else
  405.     backslash = 0;
  406.     }
  407.  
  408.   return p;
  409. }
  410.  
  411. /* Return the address of the first nonwhitespace or null in the string S.  */
  412.  
  413. char *
  414. next_token (s)
  415.      char *s;
  416. {
  417.   register char *p = s;
  418.  
  419.   while (isblank (*p))
  420.     ++p;
  421.   return p;
  422. }
  423.  
  424. /* Find the next token in PTR; return the address of it, and store the
  425.    length of the token into *LENGTHPTR if LENGTHPTR is not nil.  */
  426.  
  427. char *
  428. find_next_token (ptr, lengthptr)
  429.      char **ptr;
  430.      unsigned int *lengthptr;
  431. {
  432.   char *p = next_token (*ptr);
  433.   char *end;
  434.  
  435.   if (*p == '\0')
  436.     return 0;
  437.  
  438.   *ptr = end = end_of_token (p);
  439.   if (lengthptr != 0)
  440.     *lengthptr = end - p;
  441.   return p;
  442. }
  443.  
  444. /* Copy a chain of `struct dep', making a new chain
  445.    with the same contents as the old one.  */
  446.  
  447. struct dep *
  448. copy_dep_chain (d)
  449.      register struct dep *d;
  450. {
  451.   register struct dep *c;
  452.   struct dep *firstnew = 0;
  453.   struct dep *lastnew;
  454.  
  455.   while (d != 0)
  456.     {
  457.       c = (struct dep *) xmalloc (sizeof (struct dep));
  458.       bcopy ((char *) d, (char *) c, sizeof (struct dep));
  459.       if (c->name != 0)
  460.     c->name = savestring (c->name, strlen (c->name));
  461.       c->next = 0;
  462.       if (firstnew == 0)
  463.     firstnew = lastnew = c;
  464.       else
  465.     lastnew = lastnew->next = c;
  466.  
  467.       d = d->next;
  468.     }
  469.  
  470.   return firstnew;
  471. }
  472.  
  473. #ifdef    iAPX286
  474. /* The losing compiler on this machine can't handle this macro.  */
  475.  
  476. char *
  477. dep_name (dep)
  478.      struct dep *dep;
  479. {
  480.   return dep->name == 0 ? dep->file->name : dep->name;
  481. }
  482. #endif
  483.  
  484. #ifdef    GETLOADAVG_PRIVILEGED
  485.  
  486. #ifndef    HAVE_UNISTD_H
  487. extern int getuid (), getgid (), geteuid (), getegid ();
  488. extern int setuid (), setgid ();
  489. #ifdef    HAVE_SETREUID
  490. extern int setreuid ();
  491. #endif    /* Have setreuid.  */
  492. #ifdef    HAVE_SETREGID
  493. extern int setregid ();
  494. #endif    /* Have setregid.  */
  495. #endif    /* No <unistd.h>.  */
  496.  
  497. /* Keep track of the user and group IDs for user- and make- access.  */
  498. static int user_uid = -1, user_gid = -1, make_uid = -1, make_gid = -1;
  499. #define    access_inited    (user_uid != -1)
  500. static enum { make, user } current_access;
  501.  
  502.  
  503. /* Under -d, write a message describing the current IDs.  */
  504.  
  505. static void
  506. log_access (flavor)
  507.      char *flavor;
  508. {
  509.   if (! debug_flag)
  510.     return;
  511.  
  512.   printf ("%s access: user %d (real %d), group %d (real %d)\n",
  513.       flavor, geteuid (), getuid (), getegid (), getgid ());
  514.   fflush (stdout);
  515. }
  516.  
  517.  
  518. static void
  519. init_access ()
  520. {
  521.   user_uid = getuid ();
  522.   user_gid = getgid ();
  523.  
  524.   make_uid = geteuid ();
  525.   make_gid = getegid ();
  526.  
  527.   /* Do these ever fail?  */
  528.   if (user_uid == -1 || user_gid == -1 || make_uid == -1 || make_gid == -1)
  529.     pfatal_with_name ("get{e}[gu]id");
  530.  
  531.   log_access ("Initialized");
  532.  
  533.   current_access = make;
  534. }
  535.  
  536. #endif    /* GETLOADAVG_PRIVILEGED */
  537.  
  538. /* Give the process appropriate permissions for access to
  539.    user data (i.e., to stat files, or to spawn a child process).  */
  540. void
  541. user_access ()
  542. {
  543. #ifdef    GETLOADAVG_PRIVILEGED
  544.  
  545.   if (!access_inited)
  546.     init_access ();
  547.  
  548.   if (current_access == user)
  549.     return;
  550.  
  551.   /* We are in "make access" mode.  This means that the effective user and
  552.      group IDs are those of make (if it was installed setuid or setgid).
  553.      We now want to set the effective user and group IDs to the real IDs,
  554.      which are the IDs of the process that exec'd make.  */
  555.  
  556. #ifndef    HAVE_SETREUID
  557.  
  558.   /* System V has only the setuid/setgid calls to set user/group IDs.
  559.      There is an effective ID, which can be set by setuid/setgid.
  560.      It can be set (unless you are root) only to either what it already is
  561.      (returned by geteuid/getegid, now in make_uid/make_gid),
  562.      the real ID (return by getuid/getgid, now in user_uid/user_gid),
  563.      or the saved set ID (what the effective ID was before this set-ID
  564.      executable (make) was exec'd).  */
  565.  
  566.   if (setuid (user_uid) < 0)
  567.     pfatal_with_name ("user_access: setuid");
  568.  
  569. #else
  570.  
  571.   /* In 4BSD, the setreuid/setregid calls set both the real and effective IDs.
  572.      They may be set to themselves or each other.  So you have two alternatives
  573.      at any one time.  If you use setuid/setgid, the effective will be set to
  574.      the real, leaving only one alternative.  Using setreuid/setregid, however,
  575.      you can toggle between your two alternatives by swapping the values in a
  576.      single setreuid or setregid call.  */
  577.  
  578.   if (setreuid (make_uid, user_uid) < 0)
  579.     pfatal_with_name ("user_access: setreuid");
  580.  
  581. #endif
  582.  
  583. #ifndef    HAVE_SETREGID
  584.   if (setgid (user_gid) < 0)
  585.     pfatal_with_name ("user_access: setgid");
  586. #else
  587.   if (setregid (make_gid, user_gid) < 0)
  588.     pfatal_with_name ("user_access: setregid");
  589. #endif
  590.  
  591.   current_access = user;
  592.  
  593.   log_access ("User");
  594.  
  595. #endif    /* GETLOADAVG_PRIVILEGED */
  596. }
  597.  
  598. /* Give the process appropriate permissions for access to
  599.    make data (i.e., the load average).  */
  600. void
  601. make_access ()
  602. {
  603. #ifdef    GETLOADAVG_PRIVILEGED
  604.  
  605.   if (!access_inited)
  606.     init_access ();
  607.  
  608.   if (current_access == make)
  609.     return;
  610.  
  611.   /* See comments in user_access, above.  */
  612.  
  613. #ifndef    HAVE_SETREUID
  614.   if (setuid (make_uid) < 0)
  615.     pfatal_with_name ("make_access: setuid");
  616. #else
  617.   if (setreuid (user_uid, make_uid) < 0)
  618.     pfatal_with_name ("make_access: setreuid");
  619. #endif
  620.  
  621. #ifndef    HAVE_SETREGID
  622.   if (setgid (make_gid) < 0)
  623.     pfatal_with_name ("make_access: setgid");
  624. #else
  625.   if (setregid (user_gid, make_gid) < 0)
  626.     pfatal_with_name ("make_access: setregid");
  627. #endif
  628.  
  629.   current_access = make;
  630.  
  631.   log_access ("Make");
  632.  
  633. #endif    /* GETLOADAVG_PRIVILEGED */
  634. }
  635.  
  636. /* Give the process appropriate permissions for a child process.
  637.    This is like user_access, but you can't get back to make_access.  */
  638. void
  639. child_access ()
  640. {
  641. #ifdef    GETLOADAVG_PRIVILEGED
  642.  
  643.   if (!access_inited)
  644.     abort ();
  645.  
  646.   /* Set both the real and effective UID and GID to the user's.
  647.      They cannot be changed back to make's.  */
  648.  
  649. #ifndef    HAVE_SETREUID
  650.   if (setuid (user_uid) < 0)
  651.     pfatal_with_name ("child_access: setuid");
  652. #else
  653.   if (setreuid (user_uid, user_uid) < 0)
  654.     pfatal_with_name ("child_access: setreuid");
  655. #endif
  656.  
  657. #ifndef    HAVE_SETREGID
  658.   if (setgid (user_gid) < 0)
  659.     pfatal_with_name ("child_access: setgid");
  660. #else
  661.   if (setregid (user_gid, user_gid) < 0)
  662.     pfatal_with_name ("child_access: setregid");
  663. #endif
  664.  
  665.   log_access ("Child");
  666.  
  667. #endif    /* GETLOADAVG_PRIVILEGED */
  668. }
  669.  
  670. #ifdef NEED_GET_PATH_MAX
  671. unsigned int
  672. get_path_max ()
  673. {
  674.   static unsigned int value;
  675.  
  676.   if (value == 0)
  677.     {
  678.       long int x = pathconf ("/", _PC_PATH_MAX);
  679.       if (x > 0)
  680.     value = x;
  681.       else
  682.     return MAXPATHLEN;
  683.     }
  684.  
  685.   return value;
  686. }
  687. #endif
  688.